home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 85 / CD Temático 40 Febrero 2004.iso / DOS / testdisk / src / hdaccess.c < prev    next >
Encoding:
C/C++ Source or Header  |  2004-01-09  |  33.5 KB  |  1,111 lines
  1. /*
  2.  
  3.     File: hdaccess.c
  4.  
  5.     Copyright (C) 1998-2004 Christophe GRENIER <grenier@cgsecurity.org>
  6.   
  7.     This software is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11.   
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.   
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21.  */
  22. #include <stdio.h>
  23. #include <sys/stat.h>
  24. #include <unistd.h>    /* lseek, read, write, close */
  25. #include <string.h>
  26. #include <fcntl.h>     /* open */
  27. #include <errno.h>
  28. #ifdef DJGPP
  29. #include <stdlib.h>     /* atexit */
  30. #include <go32.h>       /* dosmemget/put */
  31. #include <dpmi.h>
  32. #include <bios.h>       /* bios_k* */
  33. #elif defined(LINUX)
  34. #include <sys/ioctl.h>
  35. #include <features.h>
  36. #include <linux/hdreg.h>
  37. #include <sys/mount.h>    /* BLKFLSBUF */
  38. #else
  39. #include <sys/ioctl.h>
  40. #include <sys/disklabel.h>
  41. #include <sys/disk.h>
  42. #endif
  43. #include "types.h"
  44. #include "common.h"
  45. #include "fnctdsk.h"
  46. #include "hdaccess.h"
  47. #include "readpart.h"
  48. #ifndef O_BINARY
  49. #define O_BINARY 0
  50. #endif
  51.  
  52. struct info_file
  53. {
  54.   int handle;
  55.   unsigned int offset;
  56.   char name[DISKNAME_MAX];
  57. };
  58.  
  59. static char *file_description(t_param_disk *disk_car);
  60. static int file_clean(t_param_disk *disk_car);
  61. static int file_read(t_param_disk *disk_car, const unsigned int nbr_sector, void *nom_buffer, const dword pos);
  62. static int file_write(t_param_disk *disk_car, const unsigned int nbr_sector, const void *nom_buffer, const dword pos);
  63. static int file_nowrite(t_param_disk *disk_car, const unsigned int nbr_sector, const void *nom_buffer, const dword pos);
  64.  
  65. #ifdef DJGPP
  66. #define HD_RW_BUF_SIZ 0x10
  67. #define HDPARM_BUF_SIZ 0x1A
  68. #define MAX_IO_NBR 3
  69. #define MAX_HD_ERR 100
  70. #define PARA_CMD         8
  71. static int hd_super(int cmd, t_param_disk *disk_car, dword hd_offset, int nsects, void *buffer);
  72. static t_param_disk *hd_identify(const int debug, const unsigned int disk);
  73. static int hd_identify_enh_bios(t_param_disk *param_disk,const int debug);
  74. static int check_enh_bios(const unsigned int disk, const int debug);
  75. static int hd_report_error(t_param_disk *disk_car, const dword hd_offset, const unsigned int nbr_sector, const int rc);
  76. static char *disk_description(t_param_disk *disk_car);
  77. static int disk_read(t_param_disk *disk_car, const unsigned int nbr_sector, void *nom_buffer, const dword hd_offset);
  78. static int disk_write(t_param_disk *disk_car, const unsigned int nbr_sector, const void *nom_buffer, const dword hd_offset);
  79. struct info_disk
  80. {
  81.   unsigned int disk;
  82.   t_CHS CHSR;    /* CHS low level */
  83.   int mode;
  84.   unsigned int nbr_err;
  85.   int bad_geometry;
  86. };
  87.  
  88. static int dos_segment = 0;
  89. static int dos_selector = 0;
  90.  
  91. void free_dos_buffer(void)
  92. {
  93.   __dpmi_free_dos_memory(dos_selector);
  94.   dos_segment = dos_selector = 0;
  95. }
  96.  
  97. int alloc_dos_buffer(void)
  98. {
  99.   if (dos_segment)
  100.     return 0;
  101.   if ((dos_segment = __dpmi_allocate_dos_memory(18*SECTOR_SIZE/16, &dos_selector))== -1)
  102.   {
  103.     dos_segment = 0;
  104.     return 1;
  105.   }
  106.   atexit(free_dos_buffer);
  107.   return 0;
  108. }
  109.  
  110. static int hd_super(int cmd, t_param_disk *disk_car, dword hd_offset, int nsects, void *buffer)
  111. { 
  112.   __dpmi_regs r;
  113.   unsigned char buf[HD_RW_BUF_SIZ];
  114.   int dos_segment2, dos_selector2, xfer2=nsects*SECTOR_SIZE;
  115.   struct info_disk*data=disk_car->data;
  116.  
  117.   if((data->mode==0)||(cmd==0))
  118.   { /* Limite CHS = 1023,255,63 = 8,064Mo ~= 7.8 Go */
  119.     int head, track, sector;
  120.     sector=(hd_offset%data->CHSR.sector)+1;
  121.     hd_offset/=data->CHSR.sector;
  122.     head=hd_offset%(data->CHSR.head+1);
  123.     track=hd_offset/(data->CHSR.head+1);
  124.     if(track<1024)
  125.       return biosdisk(cmd, data->disk, head, track, sector, nsects, buffer);
  126.     return 1;
  127.   }
  128.   if(dos_segment==0)
  129.     if(alloc_dos_buffer())
  130.       return 1;
  131.   if ( (dos_segment2=__dpmi_allocate_dos_memory((xfer2 + 15) >> 4, &dos_selector2)) == -1 )
  132.     return 1;
  133.   *(word*)&buf[0]=HD_RW_BUF_SIZ;
  134.   *(word*)&buf[2]=nsects;
  135.   *(dword*)&buf[0x4]=dos_segment2<<16;
  136.   *(dword*)&buf[0x8]=hd_offset;
  137.   *(dword*)&buf[0xC]=0;
  138.  
  139.   r.x.ds = dos_segment;
  140.   r.x.si = 0;
  141.   r.h.dl = data->disk;
  142.   switch(cmd)
  143.   {
  144.     case 2:
  145.       r.h.ah = 0x42;
  146.       break;
  147.     case 3:
  148.       r.x.ax = 0x4300;
  149.       dosmemput(buffer,xfer2,dos_segment2<<4);
  150.       break;
  151.     case 0x0C:
  152.       r.h.ah = 0x47;
  153.       break;
  154.   }
  155.   dosmemput(&buf, HD_RW_BUF_SIZ, dos_segment<<4);
  156.   __dpmi_int(0x13, &r);
  157.   if(cmd==2)
  158.     dosmemget(dos_segment2<<4, xfer2, buffer);
  159.   __dpmi_free_dos_memory(dos_selector2);
  160. #ifdef DEBUG
  161.   if(r.h.ah)
  162.   {
  163.     wdoprintf(stdscr," %lu err %02X %04X\n",*(dword*)&buf[0x8], r.h.ah,r.x.flags);
  164.   }
  165. #endif
  166.   return r.h.ah;
  167. }
  168.  
  169. static int check_enh_bios(const unsigned int disk, const int debug)
  170. {
  171.   __dpmi_regs r;
  172.   r.h.ah = 0x41;
  173.   r.x.bx = 0x55AA;
  174.   r.h.dl = disk;
  175.   __dpmi_int(0x13, &r);
  176.   if(r.x.bx != 0xAA55)  /* INT 13 Extensions not installed */
  177.   {
  178.     if(debug)
  179.       ecrit_rapport("Disk %02X - INT 13 Extensions not installed\n",disk);
  180.     return 0;
  181.   }
  182.   if(debug)
  183.   {
  184.     ecrit_rapport("Disk %02X ",disk);
  185.     switch(r.h.ah)
  186.     {
  187.       case 0x01:
  188.         ecrit_rapport("Enhanced BIOS 1.x");
  189.         break;
  190.       case 0x20:
  191.         ecrit_rapport("Enhanced BIOS 2.0 / EDD-1.0");
  192.         break;
  193.       case 0x21:
  194.         ecrit_rapport("Enhanced BIOS 2.1 / EDD-1.1");
  195.         break;
  196.       case 0x30:
  197.         ecrit_rapport("Enhanced BIOS EDD-3.0");
  198.         break;
  199.       default:
  200.         ecrit_rapport("Enhanced BIOS unknown %02X",r.h.ah);
  201.         break;
  202.     }
  203.     if((r.x.cx & 1)!=0)
  204.       ecrit_rapport(" - R/W/I");
  205.     if((r.x.cx & 4)!=0)
  206.       ecrit_rapport(" - Identify");
  207.     ecrit_rapport("\n");
  208.   }
  209.   return ((r.x.cx&1)!=0);
  210. }
  211.  
  212. static int hd_identify_enh_bios(t_param_disk *disk_car,const int debug)
  213. {
  214.   int compute_LBA=0;
  215.   __dpmi_regs r;
  216.   unsigned char buf[0x200];    /* Don't change it! */
  217.   struct info_disk*data=disk_car->data;
  218.   buf[0]=HDPARM_BUF_SIZ;
  219.   buf[1]=0;
  220.   if(dos_segment==0)
  221.     if(alloc_dos_buffer())
  222.       return 1;
  223.   r.h.ah = 0x48;
  224.   r.x.ds = dos_segment;
  225.   r.x.si = 0;
  226.   r.h.dl = data->disk;
  227.   dosmemput(&buf, HDPARM_BUF_SIZ, dos_segment<<4);
  228.   __dpmi_int(0x13, &r);
  229.   dosmemget(dos_segment<<4, HDPARM_BUF_SIZ, &buf);
  230.   if(r.h.ah)
  231.     return 1;
  232.   disk_car->CHS.cylinder=*(word*)&buf[0x04];
  233.   disk_car->CHS.head=*(word*)&buf[0x08];
  234.   disk_car->CHS.sector=*(word*)&buf[0x0C];
  235.   disk_car->size=(*(dword*)&buf[0x10]);
  236.   if(disk_car->size==0)
  237.   {
  238.     disk_car->CHS.cylinder--;
  239.     disk_car->CHS.head--;
  240.     compute_LBA=1;
  241.     disk_car->size=(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector;
  242.     if(debug)
  243.       ecrit_rapport("Computes LBA from CHS\n");
  244.   }
  245.   else
  246.   {
  247.     if(disk_car->CHS.cylinder>0 && disk_car->CHS.head>0 && disk_car->CHS.sector>0)
  248.     {
  249.       disk_car->CHS.cylinder--;
  250.       disk_car->CHS.head--;
  251.       /* Some bios are buggy */
  252.       if(disk_car->size>(disk_car->CHS.cylinder+2)*(disk_car->CHS.head+1)*disk_car->CHS.sector)
  253.       {
  254.     disk_car->CHS.cylinder=(disk_car->size/(disk_car->CHS.head+1))/disk_car->CHS.sector-1;
  255.     if(debug)
  256.       ecrit_rapport("Computes C from number of sectors\n");
  257.       }
  258.     }
  259.     else
  260.     {
  261.       if(debug)
  262.     ecrit_rapport("Computes CHS from number of sectors\n");
  263.       disk_car->CHS.head=255-1;
  264.       disk_car->CHS.sector=63;
  265.       disk_car->CHS.cylinder=(disk_car->size/(disk_car->CHS.head+1))/disk_car->CHS.sector-1;
  266.     }
  267.   }
  268.   if(disk_car->CHS.sector==0)
  269.   {
  270.     data->bad_geometry=1;
  271.     disk_car->CHS.sector=1;
  272.     ecrit_rapport("Incorrect number of sector\n");
  273.   }
  274.   if(disk_car->CHS.sector>63)
  275.   {
  276.     data->bad_geometry=1;
  277.     ecrit_rapport("Incorrect number of sector\n");
  278.   }
  279.   if(disk_car->CHS.head>255-1)
  280.   {
  281.     data->bad_geometry=1;
  282.     ecrit_rapport("Incorrect number of head\n");
  283.   }
  284.   if(debug || data->bad_geometry)
  285.     ecrit_rapport("LBA %lu, computed %u (CHS=%u,%u,%u)\n",disk_car->size, (disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector,disk_car->CHS.cylinder,disk_car->CHS.head,disk_car->CHS.sector);
  286.   if(compute_LBA)
  287.     disk_car->size=(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector;
  288.   else
  289.   {
  290.     if(disk_car->size < (disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector)
  291.     {
  292.       ecrit_rapport("Computes LBA from CHS, previous value may be false.\n");
  293.       disk_car->size=(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector;
  294.     }
  295.   }
  296.   data->CHSR.cylinder=disk_car->CHS.cylinder;
  297.   data->CHSR.head=disk_car->CHS.head;
  298.   data->CHSR.sector=disk_car->CHS.sector;
  299.   if(debug)
  300.   {
  301.     ecrit_rapport("hd_identify_enh_bios\n");
  302.     ecrit_rapport("%s",disk_description(disk_car));
  303.     ecrit_rapport("LBA size=%lu\n",disk_car->size);
  304.   }
  305.   return 0;
  306. }
  307.  
  308. static t_param_disk *hd_identify(const int debug, const unsigned int disk)
  309. {
  310.   unsigned char buf[0x200];
  311.   memset(buf,0,sizeof(buf));
  312.   /* standard BIOS access */
  313.   if(biosdisk(PARA_CMD,disk,0,0,1,1,buf))
  314.     return NULL;
  315.   if(debug>1)
  316.     ecrit_rapport("Disk %02X %u max %02X\n",disk,buf[2],(0x80+buf[2]-1));
  317.   if(disk>(unsigned int)(0x80+buf[2]-1))
  318.     return NULL;
  319.   {
  320.     struct info_disk*data=(struct info_disk*)MALLOC(sizeof(*data));
  321.     t_param_disk *disk_car=(t_param_disk *)MALLOC(sizeof(*disk_car));
  322.     data->disk=disk;
  323.     data->bad_geometry=0;
  324.     data->mode=0;
  325.     data->nbr_err=0;
  326.     disk_car->halt_on_errors=0;
  327.     disk_car->write_used=0;
  328.     disk_car->description=disk_description;
  329.     disk_car->read=disk_read;
  330.     disk_car->write=disk_write;
  331.     disk_car->clean=file_clean;
  332.     disk_car->data=data;
  333.     disk_car->CHS.cylinder=((buf[0] & 0x0C0)<<2)|buf[1];
  334.     disk_car->CHS.head=buf[3];
  335.     disk_car->CHS.sector=buf[0] & 0x3F;
  336.     if(disk_car->CHS.head>=255)
  337.     { /* Problem found by G Rowe */
  338.       ecrit_rapport("BIOS reports an invalid heads number\n");
  339.       data->bad_geometry=1;
  340.       disk_car->CHS.head=254;
  341.     }
  342.     if(disk_car->CHS.sector==0)
  343.     { /* Problem found by Brian Barrett */
  344.       ecrit_rapport("BIOS reports an invalid number of sector per head\n");
  345.       data->bad_geometry=1;
  346.       disk_car->CHS.sector=1;
  347.     }
  348.     disk_car->size=(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector;
  349.     data->CHSR.cylinder=disk_car->CHS.cylinder;
  350.     data->CHSR.head=disk_car->CHS.head;
  351.     data->CHSR.sector=disk_car->CHS.sector;
  352.     if(debug)
  353.       ecrit_rapport("%s",disk_description(disk_car));
  354.     if(check_enh_bios(disk,debug))
  355.     {
  356.       /* enhanced BIOS access */
  357.       t_param_disk *param_disk_enh=(t_param_disk*)MALLOC(sizeof(*param_disk_enh));
  358.       param_disk_enh->halt_on_errors=0;
  359.       param_disk_enh->write_used=0;
  360.       param_disk_enh->data=data;
  361.       data->mode=1;
  362.       if(!hd_identify_enh_bios(param_disk_enh,debug))
  363.       {
  364.     /* standard geometry H,S, compute C from LBA */
  365.     disk_car->size=param_disk_enh->size;
  366.     disk_car->CHS.cylinder=(disk_car->size/(disk_car->CHS.head+1))/disk_car->CHS.sector-1;
  367.       }
  368.       else
  369.     data->mode=0;
  370.       FREE(param_disk_enh);
  371.     }
  372.     return disk_car;
  373.   }
  374. }
  375.  
  376. static char *disk_description(t_param_disk *disk_car)
  377. {
  378.   struct info_disk*data=disk_car->data;
  379.   sprintf(disk_car->description_txt, "Disk %2x - CHS %u %u %u - %u MB %s\n",
  380.       data->disk, disk_car->CHS.cylinder+1, disk_car->CHS.head+1, disk_car->CHS.sector,(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector/2/1024,data->bad_geometry?" (Buggy BIOS)":"");
  381.   return disk_car->description_txt;
  382. }
  383.  
  384. static int disk_read(t_param_disk *disk_car,const unsigned int nbr_sector, void *nom_buffer, const dword hd_offset)
  385. {
  386.   struct info_disk*data=disk_car->data;
  387.   /* CHS=(0,1,1) */
  388.   if(hd_offset==disk_car->CHS.sector)
  389.   {
  390.     data->nbr_err=0;
  391.   }
  392.   if((data->nbr_err>MAX_HD_ERR)&&disk_car->halt_on_errors)
  393.   {
  394.     if(data->nbr_err==(MAX_HD_ERR+1))
  395.     {
  396.       ecrit_rapport("\ndata->nbr_err>MAX_HD_ERR !!!\n");
  397.       data->nbr_err++;
  398.     }
  399.     return 1;
  400.   }
  401.   if((data->CHSR.cylinder==0) || (hd_offset+nbr_sector-1<=disk_car->size))
  402.   {
  403.     int rc=0;
  404.     unsigned int offset=0;
  405.     unsigned int read_size;
  406.     for(offset=0;(rc==0) && (offset<nbr_sector);offset+=read_size)
  407.     {
  408.       int i;
  409.       read_size=nbr_sector-offset>16?16:nbr_sector-offset;
  410.       rc=4; /* sector not found/read error */
  411.       for(i=0;(rc!=0) && (rc!=1) && (i<MAX_IO_NBR);i++)
  412.       {
  413.     rc=hd_super(2, disk_car, hd_offset+offset, read_size, (char*)nom_buffer+offset*SECTOR_SIZE);
  414.     if(rc!=0)
  415.     {
  416.       hd_super(0, disk_car, 0, 1, NULL);
  417.     }
  418.       }
  419.     }
  420.     if(rc!=0)
  421.     {
  422.       ecrit_rapport("disk_read");
  423.       hd_report_error(disk_car,hd_offset,nbr_sector,rc);
  424.     }
  425.     return rc;
  426.   }
  427.   return 1;
  428. }
  429.  
  430. static int disk_write(t_param_disk *disk_car,const unsigned int nbr_sector, const void *nom_buffer, const dword hd_offset)
  431. {
  432.   struct info_disk*data=disk_car->data;
  433.   disk_car->write_used=1;
  434.   if((data->nbr_err>MAX_HD_ERR)&&disk_car->halt_on_errors)
  435.   {
  436.     if(data->nbr_err==(MAX_HD_ERR+1))
  437.     {
  438.       ecrit_rapport("\ndata->nbr_err>MAX_HD_ERR !!!\n");
  439.       data->nbr_err++;
  440.     }
  441.     return 1;
  442.   }
  443.   {
  444.     int i,rc=4; /* sector not found/read error */
  445.     for(i=0;(rc==4)&&(i<MAX_IO_NBR);i++)
  446.     {
  447.       rc=hd_super(3, disk_car, hd_offset, nbr_sector, nom_buffer);
  448.     }
  449.     if(rc)
  450.     {
  451.       ecrit_rapport("disk_write");
  452.       hd_report_error(disk_car,hd_offset,nbr_sector,rc);
  453.     }
  454.     return rc;
  455.   }
  456. }
  457.  
  458. static int hd_report_error(t_param_disk *disk_car, const dword hd_offset, const unsigned int nbr_sector, const int rc)
  459. {
  460.   struct info_disk*data=disk_car->data;
  461.   data->nbr_err++;
  462.   ecrit_rapport(" lba=%lu(%u/%u/%u) nbr_sector=%u, rc=%d\n",hd_offset,
  463.       LBA2cylinder(disk_car,hd_offset),LBA2head(disk_car,hd_offset),LBA2sector(disk_car,hd_offset),
  464.       nbr_sector,rc);
  465.   switch(rc)
  466.   {
  467.     case 0x00: ecrit_rapport("successful completion"); break;
  468.     case 0x01: ecrit_rapport("invalid function in AH or invalid parameter"); break;
  469.     case 0x02: ecrit_rapport("address mark not found"); break;
  470.     case 0x03: ecrit_rapport("disk write-protected"); break;
  471.     case 0x04: ecrit_rapport("sector not found/read error"); break;
  472.     case 0x05: ecrit_rapport("reset failed (hard disk)"); break;
  473.     case 0x06: ecrit_rapport("disk changed (floppy)"); break;
  474.     case 0x07: ecrit_rapport("drive parameter activity failed (hard disk)"); break;
  475.     case 0x08: ecrit_rapport("DMA overrun"); break;
  476.     case 0x09: ecrit_rapport("data boundary error (attempted DMA across 64K boundary or >80h sectors)"); break;
  477.     case 0x0A: ecrit_rapport("bad sector detected (hard disk)"); break;
  478.     case 0x0B: ecrit_rapport("bad track detected (hard disk)"); break;
  479.     case 0x0C: ecrit_rapport("unsupported track or invalid media"); break;
  480.     case 0x0D: ecrit_rapport("invalid number of sectors on format (PS/2 hard disk)"); break;
  481.     case 0x0E: ecrit_rapport("control data address mark detected (hard disk)"); break;
  482.     case 0x0F: ecrit_rapport("DMA arbitration level out of range (hard disk)"); break;
  483.     case 0x10: ecrit_rapport("uncorrectable CRC or ECC error on read"); break;
  484.     case 0x11: ecrit_rapport("data ECC corrected (hard disk)"); break;
  485.     case 0x20: ecrit_rapport("controller failure"); break;
  486.     case 0x31: ecrit_rapport("no media in drive (IBM/MS INT 13 extensions)"); break;
  487.     case 0x32: ecrit_rapport("incorrect drive type stored in CMOS (Compaq)"); break;
  488.     case 0x40: ecrit_rapport("seek failed"); break;
  489.     case 0x80: ecrit_rapport("timeout (not ready)"); break;
  490.     case 0xAA: ecrit_rapport("drive not ready (hard disk)"); break;
  491.     case 0xB0: ecrit_rapport("volume not locked in drive (INT 13 extensions)"); break;
  492.     case 0xB1: ecrit_rapport("volume locked in drive (INT 13 extensions)"); break;
  493.     case 0xB2: ecrit_rapport("volume not removable (INT 13 extensions)"); break;
  494.     case 0xB3: ecrit_rapport("volume in use (INT 13 extensions)"); break;
  495.     case 0xB4: ecrit_rapport("lock count exceeded (INT 13 extensions)"); break;
  496.     case 0xB5: ecrit_rapport("valid eject request failed (INT 13 extensions)"); break;
  497.     case 0xB6: ecrit_rapport("volume present but read protected (INT 13 extensions)"); break;
  498.     case 0xBB: ecrit_rapport("undefined error (hard disk)"); break;
  499.     case 0xCC: ecrit_rapport("write fault (hard disk)"); break;
  500.     case 0xE0: ecrit_rapport("status register error (hard disk)"); break;
  501.     case 0xFF: ecrit_rapport("sense operation failed (hard disk)"); break;
  502.   }
  503.   ecrit_rapport("\n");
  504.   return 0;
  505. }
  506.  
  507. t_list_disk *hd_parse(t_list_disk *list_disk,const int debug)
  508. {
  509.   int i;
  510.   int ind_stop=0;
  511.   for(i=0x80;(i<0x88)&&!ind_stop;i++)
  512.   {
  513.     t_param_disk *disk_car=hd_identify(debug,i);
  514.     if(disk_car)
  515.       list_disk=insert_new_disk(list_disk,disk_car);
  516.     else
  517.       ind_stop=1;
  518.   }
  519.   /* hdimage */
  520.   {
  521.     t_param_disk *disk_car=file_test_availability( "hdimage",debug);
  522.     if(disk_car)
  523.       list_disk=insert_new_disk(list_disk,disk_car);
  524.   }
  525.   return list_disk;
  526. }
  527. #elif defined(LINUX)
  528. static t_param_disk *disk_get_geometry(const int hd_h, const char *device, const int debug);
  529.  
  530. static t_param_disk *disk_get_geometry(const int hd_h, const char *device, const int debug)
  531. {
  532.   t_param_disk *disk_car=NULL;
  533.   /* Little trick from Linux fdisk */
  534.   /* Blocks are visible in more than one way:
  535.      e.g. as block on /dev/hda and as block on /dev/hda3
  536.      By a bug in the Linux buffer cache, we will see the old
  537.      contents of /dev/hda when the change was made to /dev/hda3.
  538.      In order to avoid this, discard all blocks on /dev/hda. */
  539.   ioctl(hd_h, BLKFLSBUF);    /* ignore errors */
  540.   /* e.g. Permission Denied */
  541. #ifdef HDIO_GETGEO_BIG
  542.   {
  543.     struct hd_big_geometry geometry_big;
  544.     if (ioctl(hd_h, HDIO_GETGEO_BIG, &geometry_big)==0)
  545.     { /* I can get the geometry */
  546.       if(debug>1)
  547.       {
  548.     ecrit_rapport("disk_get_geometry %s HDIO_GETGEO_BIG Ok\n",device);
  549.       }
  550.       disk_car=(t_param_disk *)MALLOC(sizeof(*disk_car));
  551.       disk_car->CHS.cylinder= geometry_big.cylinders-1;
  552.       disk_car->CHS.head=geometry_big.heads-1;
  553.       disk_car->CHS.sector= geometry_big.sectors;
  554.     }
  555.     else
  556.     {
  557.       if(debug>1)
  558.       {
  559.     ecrit_rapport("disk_get_geometry %s: HDIO_GETGEO_BIG failed\n",device);
  560.       }
  561.     }
  562.   }
  563. #endif
  564.   if (disk_car==NULL)
  565.   {
  566.     struct hd_geometry geometry;
  567.     if(ioctl(hd_h, HDIO_GETGEO, &geometry)==0)
  568.     { /* I can get the geometry */
  569.       if(debug>1)
  570.       {
  571.     ecrit_rapport("disk_get_geometry %s HDIO_GETGEO Ok\n",device);
  572.       }
  573.       disk_car=(t_param_disk *)MALLOC(sizeof(*disk_car));
  574.       disk_car->CHS.cylinder= geometry.cylinders-1;
  575.       disk_car->CHS.head=geometry.heads-1;
  576.       disk_car->CHS.sector= geometry.sectors;
  577.     }
  578.   }
  579.   return disk_car;
  580. }
  581.  
  582. t_list_disk *hd_parse(t_list_disk *list_disk,const int debug)
  583. {
  584.   int i,j;
  585.   char device_ide[]="/dev/hda";
  586.   char device_scsi[]="/dev/sda";
  587.   char device_ida[]="/dev/ida/c0d0";
  588.   char device_cciss[]="/dev/cciss/c0d0";
  589.   char device_rd[]="/dev/rd/c0d0";
  590.   char device_rd_ide[]="/dev/ataraid/d0";
  591.   char device_p_ide[]="/dev/pda";
  592.   char device_i2o_hd[]="/dev/i2o/hda";
  593.   /* Disk IDE */
  594.   for(i=0;i<8;i++)
  595.   {
  596.     device_ide[strlen(device_ide)-1]='a'+i;
  597.     list_disk=insert_new_disk(list_disk,file_test_availability(device_ide,debug));
  598.   }
  599.   /* Disk SCSI */
  600.   for(i=0;i<26;i++)
  601.   {
  602.     device_scsi[strlen(device_scsi)-1]='a'+i;
  603.     list_disk=insert_new_disk(list_disk,file_test_availability(device_scsi,debug));
  604.   }
  605.   /* Device RAID Compaq */
  606.   for(j=0;j<8;j++)
  607.   {
  608.     device_ida[strlen(device_ida)-3]='0'+j;
  609.     for(i=0;i<8;i++)
  610.     {
  611.       device_ida[strlen(device_ida)-1]='0'+i;
  612.       list_disk=insert_new_disk(list_disk,file_test_availability(device_ida,debug));
  613.     }
  614.   }
  615.   for(i=0;i<8;i++)
  616.   {
  617.     device_cciss[strlen(device_cciss)-1]='0'+i;
  618.     list_disk=insert_new_disk(list_disk,file_test_availability(device_cciss,debug));
  619.   }
  620.   /* Device RAID */
  621.   for(i=0;i<10;i++)
  622.   {
  623.     device_rd[strlen(device_rd)-1]='0'+i;
  624.     list_disk=insert_new_disk(list_disk,file_test_availability(device_rd,debug));
  625.   }
  626.   /* Device RAID IDE */
  627.   for(i=0;i<15;i++)
  628.   {
  629.     device_rd_ide[strlen(device_rd_ide)-1]='0'+i;
  630.     list_disk=insert_new_disk(list_disk,file_test_availability(device_rd_ide,debug));
  631.   }
  632.   /* Parallel port IDE disk */
  633.   for(i=0;i<4;i++)
  634.   {
  635.     device_p_ide[strlen(device_p_ide)-1]='a'+i;
  636.     list_disk=insert_new_disk(list_disk,file_test_availability(device_p_ide,debug));
  637.   }
  638.   /* I2O hard disk */
  639.   for(i=0;i<26;i++)
  640.   {
  641.     device_i2o_hd[strlen(device_i2o_hd)-1]='a'+i;
  642.     list_disk=insert_new_disk(list_disk,file_test_availability(device_i2o_hd,debug));
  643.   }
  644. /* hdimage */
  645.   list_disk=insert_new_disk(list_disk,file_test_availability("hdimage",debug));
  646. #ifdef TEST
  647.   {
  648.     t_list_disk *disk;
  649.     for(disk=list_disk;disk;disk=disk->next)
  650.     {
  651.       disk->disk=new_diskcache(disk->disk);
  652.     }
  653.   }
  654. #endif
  655.   return list_disk;
  656. }
  657. #else
  658. static t_param_disk *disk_get_geometry(const int hd_h, const char *device, const int debug);
  659.  
  660. static t_param_disk *disk_get_geometry(const int hd_h, const char *device, const int debug)
  661. {
  662.   t_param_disk *disk_car=NULL;
  663.   struct disklabel geometry;
  664.   if (ioctl(hd_h, DIOCGDINFO, &geometry)==0)
  665.   { /* I can get the geometry */
  666.     if(debug>1)
  667.     {
  668.       ecrit_rapport("disk_get_geometry %s: Ok\n",device);
  669.     }
  670.     disk_car=(t_param_disk *)MALLOC(sizeof(*disk_car));
  671.     disk_car->CHS.cylinder=geometry.d_ncylinders-1;
  672.     disk_car->CHS.head=geometry.d_ntracks-1;
  673.     disk_car->CHS.sector=geometry.d_nsectors;
  674.   }
  675.   else
  676.   {
  677.     int error;
  678.     u_int u,sectors,heads,cyls;
  679.     off_t o;
  680.     if(debug>1)
  681.     {
  682.       ecrit_rapport("disk_get_geometry %s: DIOCGDINFO failed %s\n",device,strerror(errno));
  683.     }
  684.     error = ioctl(hd_h, DIOCGFWSECTORS, &u);
  685.     if(error==0 && u>0)
  686.     {
  687.       sectors=u;
  688.     }
  689.     else
  690.     {
  691.       sectors=63;
  692.       if(debug>1)
  693.       {
  694.     ecrit_rapport("disk_get_geometry %s: DIOCGFWSECTORS failed %s\n",device,strerror(errno));
  695.       }
  696.     }
  697.     error = ioctl(hd_h, DIOCGFWHEADS, &u);
  698.     if(error==0 && u>0)
  699.     {
  700.       heads=u;
  701.     }
  702.     else
  703.     {
  704.       heads=255;
  705.       if(debug>1)
  706.       {
  707.     ecrit_rapport("disk_get_geometry %s: DIOCGFWHEADS failed %s\n",device,strerror(errno));
  708.       }
  709.     }
  710.     error = ioctl(hd_h, DIOCGMEDIASIZE, &o);
  711.     if(error==0)
  712.     {
  713.       cyls = o / (512 * heads * sectors);
  714.       disk_car=(t_param_disk *)MALLOC(sizeof(*disk_car));
  715.       disk_car->CHS.cylinder=cyls-1;
  716.       disk_car->CHS.head=heads-1;
  717.       disk_car->CHS.sector=sectors;
  718.     }
  719.     else
  720.     {
  721.       if(debug>1)
  722.       {
  723.     ecrit_rapport("disk_get_geometry %s: DIOCGMEDIASIZE failed %s\n",device,strerror(errno));
  724.       }
  725.     }
  726.   }
  727.   return disk_car;
  728. }
  729.  
  730. t_list_disk *hd_parse(t_list_disk *list_disk,const int debug)
  731. {
  732.   /* Need to check http://mattriffle.com/mirrors/freebsd/doc/en_US.ISO8859-1/books/handbook/disks-naming.html#DISK-NAMING-PHYSICAL-TABLE */
  733.   int i;
  734.   char device_ide[]= "/dev/rwd0";    /* raw winchester disk */
  735.   char device_ide2[]="/dev/rad0";
  736.   char device_scsi[]="/dev/rda0";    /* raw scsci disk */
  737.   char device_optdisk[]="/dev/rod0";
  738.   char device_ide_hd[]="/dev/ad0";
  739.   char device_scsi_hd[]="/dev/da0";
  740. /* wd da */
  741.   /* Disk IDE */
  742.   for(i=0;i<8;i++)
  743.   {
  744.     device_ide[strlen(device_ide)-1]='0'+i;
  745.     list_disk=insert_new_disk(list_disk,file_test_availability(device_ide,debug));
  746.   }
  747.   for(i=0;i<8;i++)
  748.   {
  749.     device_ide2[strlen(device_ide2)-1]='0'+i;
  750.     list_disk=insert_new_disk(list_disk,file_test_availability(device_ide2,debug));
  751.   }
  752.   for(i=0;i<8;i++)
  753.   {
  754.     device_ide_hd[strlen(device_ide_hd)-1]='0'+i;
  755.     list_disk=insert_new_disk(list_disk,file_test_availability(device_ide_hd,debug));
  756.   }
  757.   /* Disk SCSI */
  758.   for(i=0;i<8;i++)
  759.   {
  760.     device_scsi[strlen(device_scsi)-1]='0'+i;
  761.     list_disk=insert_new_disk(list_disk,file_test_availability(device_scsi,debug));
  762.   }
  763.   for(i=0;i<8;i++)
  764.   {
  765.     device_scsi_hd[strlen(device_scsi_hd)-1]='0'+i;
  766.     list_disk=insert_new_disk(list_disk,file_test_availability(device_scsi_hd,debug));
  767.   }
  768.   /* optical disks */
  769.   for(i=0;i<8;i++)
  770.   {
  771.     device_optdisk[strlen(device_scsi)-1]='a'+i;
  772.     list_disk=insert_new_disk(list_disk,file_test_availability(device_optdisk,debug));
  773.   } 
  774.   /* */
  775.  
  776.   /* hdimage */
  777.   list_disk=insert_new_disk(list_disk,file_test_availability("hdimage",debug));
  778.   return list_disk;
  779. }
  780. #endif
  781.  
  782. static char *file_description(t_param_disk *disk_car)
  783. {
  784.   struct info_file *data=disk_car->data;
  785.   snprintf(disk_car->description_txt, sizeof(disk_car->description_txt),"Disk %s - CHS %u %u %u - %u MB\n",
  786.       data->name, disk_car->CHS.cylinder+1, disk_car->CHS.head+1, disk_car->CHS.sector,(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector/2/1024);
  787.   return disk_car->description_txt;
  788. }
  789.  
  790. static int file_clean(t_param_disk *disk_car)
  791. {
  792.   if(disk_car->data!=NULL)
  793.   {
  794.     FREE(disk_car->data);
  795.     disk_car->data=NULL;
  796.   }
  797.   return 0;
  798. }
  799.  
  800. static int file_read(t_param_disk *disk_car,const unsigned int nbr_sector, void *nom_buffer, dword pos)
  801. {
  802.   struct info_file *data=disk_car->data;
  803.   long int ret;
  804. /* ecrit_rapport("file_read(%d,%u,buffer,%lu(%u/%u/%u))\n", data->handle,nbr_sector,pos, */
  805. /*     LBA2cylinder(disk_car,pos),LBA2head(disk_car,pos),LBA2sector(disk_car,pos)); */
  806. #ifdef TESTING
  807.   if(rand()%10==0)    /* TEST ONLY ICI */
  808.   {
  809. /*   ecrit_rapport("file_read(%u,%u,buffer,%lu) seek err\n", data->handle,nbr_sector,pos); */
  810.     return -1;
  811.   }
  812.   if(LBA2cylinder(disk_car,pos)>1 && LBA2cylinder(disk_car,pos)<600)
  813.   {
  814.     memset(nom_buffer,0,nbr_sector*SECTOR_SIZE);
  815.     return 0;
  816.   }
  817. #endif
  818.   if(lseek(data->handle,((loff_t)pos<<9)+(loff_t)data->offset,SEEK_SET)==-1)
  819.   {
  820.     ecrit_rapport("file_read(%d,%u,buffer,%lu(%u/%u/%u)) seek err %s\n", data->handle,nbr_sector,pos,
  821.       LBA2cylinder(disk_car,pos),LBA2head(disk_car,pos),LBA2sector(disk_car,pos),strerror(errno));
  822.     return -1;
  823.   }
  824.   ret=read(data->handle, nom_buffer, nbr_sector*SECTOR_SIZE);
  825.   if(ret!=(long int)(nbr_sector*SECTOR_SIZE))
  826.   {
  827.     ecrit_rapport("file_read(%d,%u,buffer,%lu(%u/%u/%u)) read err %s (ret!=nbr_sector*SECTOR_SIZE)\n", data->handle,nbr_sector,pos,
  828.       LBA2cylinder(disk_car,pos),LBA2head(disk_car,pos),LBA2sector(disk_car,pos),(ret==-1?strerror(errno):"Truncated file"));
  829.     return -1;
  830.   }
  831.   return 0;
  832. }
  833.  
  834. static int file_write(t_param_disk *disk_car,const unsigned int nbr_sector, const void *nom_buffer, const dword pos)
  835. {
  836.   long int ret;
  837.   struct info_file *data=disk_car->data;
  838.   if(lseek(data->handle,((loff_t)pos<<9)+(loff_t)(data->offset),SEEK_SET)==-1)
  839.   {
  840.     ecrit_rapport("file_write(%d,%u,buffer,%lu(%u/%u/%u)) seek err %s\n", data->handle,nbr_sector,pos,
  841.       LBA2cylinder(disk_car,pos),LBA2head(disk_car,pos),LBA2sector(disk_car,pos),strerror(errno));
  842.     return -1;
  843.   }
  844.   disk_car->write_used=1;
  845.   ret=write(data->handle, nom_buffer, nbr_sector*SECTOR_SIZE);
  846.   if(ret!=(long int)nbr_sector*SECTOR_SIZE)
  847.   {
  848.     ecrit_rapport("file_write(%d,%u,buffer,%lu(%u/%u/%u)) write err %s\n", data->handle,nbr_sector,pos,
  849.       LBA2cylinder(disk_car,pos),LBA2head(disk_car,pos),LBA2sector(disk_car,pos),(ret==-1?strerror(errno):"File truncated"));
  850.     return -1;
  851.   }
  852.   return 0;
  853. }
  854.  
  855. static int file_nowrite(t_param_disk *disk_car,const unsigned int nbr_sector, const void *nom_buffer, const dword pos)
  856. {
  857.   struct info_file *data=disk_car->data;
  858.   ecrit_rapport("write_file(%d,%u,buffer,%lu(%u/%u/%u)) write refused\n", data->handle,nbr_sector,pos,
  859.       LBA2cylinder(disk_car,pos),LBA2head(disk_car,pos),LBA2sector(disk_car,pos));
  860.   return -1;
  861. }
  862.  
  863. t_param_disk *file_test_availability(const char *device, const int debug)
  864. {
  865.   unsigned int offset=0;
  866.   t_param_disk *disk_car=NULL;
  867.   int hd_h;
  868.   int no_write=0;
  869. #ifdef O_LARGEFILE
  870.   hd_h = open(device, O_RDWR|O_LARGEFILE|O_BINARY);
  871. #else
  872.   hd_h = open(device, O_RDWR|O_BINARY);
  873. #endif
  874.   if(hd_h<0)
  875.   {
  876.     if(debug>1)
  877.     {
  878.       ecrit_rapport("file_test_availability %s:%s\n", device,strerror(errno));
  879.     }
  880. /*   if(errno==EROFS||errno==EACCES|errno==EPERM) */
  881.     {
  882.       no_write=1;
  883. #ifdef O_LARGEFILE
  884.       hd_h = open(device, O_RDONLY|O_LARGEFILE|O_BINARY);
  885. #else
  886.       hd_h = open(device, O_RDONLY|O_BINARY);
  887. #endif
  888.       if(hd_h<0)
  889.       {
  890.     if(debug>1)
  891.     {
  892.       ecrit_rapport("file_test_availability %s:%s\n", device,strerror(errno));
  893.     }
  894.       }
  895.     }
  896.   }
  897.   if(hd_h>0)
  898.   {
  899.     struct stat stat_rec;
  900.     if(fstat(hd_h,&stat_rec)<0)
  901.     {
  902.       if(debug>1)
  903.       {
  904.     ecrit_rapport("file_test_availability %s: fstat failed\n",device);
  905.       }
  906.       close(hd_h);
  907.       return NULL;
  908.     }
  909.     if(!S_ISREG(stat_rec.st_mode))
  910.     {
  911.       if(debug>1)
  912.       {
  913.     ecrit_rapport("file_test_availability %s: not a regular file\n",device);
  914.       }
  915. #ifndef DJGPP
  916.       disk_car=disk_get_geometry(hd_h, device, debug);
  917.       if(disk_car!=NULL)
  918.       {
  919.     disk_car->size=(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector;
  920.       }
  921. #endif
  922.     }
  923.     else
  924.     {
  925.       unsigned char buffer[SECTOR_SIZE];
  926.       if(read(hd_h,buffer,sizeof(buffer))!=sizeof(buffer))
  927.       {
  928.     close(hd_h);
  929.     return NULL;
  930.       }
  931.       if(memcmp(buffer,"DOSEMU",6)==0)
  932.       {
  933.     if(*(unsigned long*)(buffer+11)==0)
  934.     {
  935.       ecrit_rapport("%s corrupted DOSEMU file\n",device);
  936.       close(hd_h);
  937.       return NULL;
  938.     }
  939.     if(debug)
  940.     {
  941.       ecrit_rapport("%s DOSEMU\n",device);
  942.     }
  943.     disk_car=(t_param_disk *)MALLOC(sizeof(*disk_car));
  944.     disk_car->CHS.head=*(unsigned long*)(buffer+7)-1;
  945.     disk_car->CHS.sector=*(unsigned long*)(buffer+11);
  946.     disk_car->CHS.cylinder=*(unsigned long*)(buffer+15)-1;
  947.     disk_car->size=(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector;
  948.     offset=*(unsigned long*)(buffer+19);
  949.       }
  950.       else
  951.       {
  952.     t_CHS geometry;
  953.     disk_car=(t_param_disk *)MALLOC(sizeof(*disk_car));
  954.     disk_car->size=(stat_rec.st_size-offset)/SECTOR_SIZE;
  955.     get_geometry_from_mbr(buffer, debug, &geometry);
  956.     if(geometry.sector>0)
  957.     {
  958.       disk_car->CHS.head=geometry.head;
  959.       disk_car->CHS.sector=geometry.sector;
  960.     }
  961.     else
  962.     {
  963.       disk_car->CHS.head=255-1;
  964.       disk_car->CHS.sector=63;
  965.     }
  966.     /* Round up because file is often truncated. */
  967.     disk_car->CHS.cylinder=(disk_car->size+disk_car->CHS.sector*(disk_car->CHS.head+1)-1)/disk_car->CHS.sector/(disk_car->CHS.head+1)-1;
  968.       }
  969.     }
  970.     if(disk_car!=NULL)
  971.     {
  972.       struct info_file *data=MALLOC(sizeof(*data));
  973.       data->offset=offset;
  974.       strncpy(data->name,device,sizeof(data->name));
  975.       data->handle=hd_h;
  976.       disk_car->halt_on_errors=0;
  977.       disk_car->write_used=0;
  978.       disk_car->description=file_description;
  979.       disk_car->read=file_read;
  980.       disk_car->write=(no_write==0?file_write:file_nowrite);
  981.       disk_car->clean=file_clean;
  982.       disk_car->data=data;
  983.       return disk_car;
  984.     }
  985.     else
  986.     {
  987.       close(hd_h);
  988.     }
  989.   }
  990.   return NULL;
  991. }
  992.  
  993. void hd_parse_bis(const t_list_disk * list_disk, const int allow_partial_last_cylinder)
  994. {
  995.   const t_list_disk *element_disk;
  996.   for(element_disk=list_disk;element_disk;element_disk=element_disk->next)
  997.   {
  998.     t_param_disk *disk_car=element_disk->disk;
  999.     char buffer[SECTOR_SIZE];
  1000.     dword pos;
  1001.     t_CHS pos_CHS;
  1002.     dup_t_CHS(&pos_CHS,&disk_car->CHS);
  1003.     pos_CHS.cylinder++;
  1004.     if(allow_partial_last_cylinder) {
  1005.       pos_CHS.head=0;
  1006.       pos_CHS.sector=1;
  1007.     }
  1008.     pos=CHS2LBA(disk_car,&pos_CHS);
  1009. #ifdef DJGPP
  1010.     if(disk_car->description==disk_description)
  1011.     {
  1012.       struct info_disk*data=disk_car->data;
  1013.       data->CHSR.cylinder=0;
  1014.     }
  1015. #endif
  1016.     if(disk_car->read(element_disk->disk,1, &buffer, pos)==0)
  1017.     {
  1018.       disk_car->CHS.cylinder++;
  1019.       if(disk_car->size < (disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector)
  1020.       {
  1021.     disk_car->size=(disk_car->CHS.cylinder+1)*(disk_car->CHS.head+1)*disk_car->CHS.sector;
  1022.     ecrit_rapport("Computes LBA from CHS for %s\n",disk_car->description(disk_car));
  1023.       }
  1024.     }
  1025. #ifdef DJGPP
  1026.     if(disk_car->description==disk_description)
  1027.     {
  1028.       struct info_disk*data=disk_car->data;
  1029.       data->CHSR.cylinder=disk_car->CHS.cylinder;
  1030.     }
  1031. #endif
  1032.   }
  1033. }
  1034.  
  1035. #ifdef TEST
  1036. struct info_cache
  1037. {
  1038.   t_param_disk *disk_car;
  1039.   unsigned int nbr_read;
  1040.   unsigned int nbr_write;
  1041. };
  1042.  
  1043. static int cache_read(t_param_disk *disk_car,const unsigned int nbr_sector, void *nom_buffer, const dword pos);
  1044. static int cache_write(t_param_disk *disk_car,const unsigned int nbr_sector, const void *nom_buffer, const dword pos);
  1045. static int cache_clean(t_param_disk *clean);
  1046.  
  1047. static int cache_read(t_param_disk *disk_car,const unsigned int nbr_sector, void *nom_buffer, const dword pos)
  1048. {
  1049.   static char buffer[8*SECTOR_SIZE];
  1050.   static dword old_pos=1234;
  1051.   int res=0;
  1052.   struct info_cache *data=disk_car->data;
  1053.   ecrit_rapport("cache_read(%u,buffer,%lu(%u/%u/%u))\n", nbr_sector,pos,
  1054.       LBA2cylinder(disk_car,pos),LBA2head(disk_car,pos),LBA2sector(disk_car,pos));
  1055.   if(nbr_sector>8)
  1056.   {
  1057.     data->nbr_read+=nbr_sector;
  1058.     return data->disk_car->read(data->disk_car,nbr_sector,nom_buffer,pos);
  1059.   }
  1060.   if(pos!=old_pos)
  1061.   {
  1062.     res=data->disk_car->read(data->disk_car,8,buffer,pos);
  1063.     data->nbr_read+=8;
  1064.   } else {
  1065.     ecrit_rapport("Cached\n");
  1066.   }
  1067.   memcpy(nom_buffer,buffer,nbr_sector*SECTOR_SIZE);
  1068.   return res;
  1069. }
  1070.  
  1071. static int cache_write(t_param_disk *disk_car,const unsigned int nbr_sector, const void *nom_buffer, const dword pos)
  1072. {
  1073.   struct info_cache *data=disk_car->data;
  1074.   data->nbr_write+=nbr_sector;
  1075.   disk_car->write_used=1;
  1076.   return data->disk_car->write(data->disk_car,nbr_sector,nom_buffer,pos);
  1077. }
  1078.  
  1079. static int cache_clean(t_param_disk *disk_car)
  1080. {
  1081.   if(disk_car->data)
  1082.   {
  1083.     struct info_cache *data=disk_car->data;
  1084.     ecrit_rapport("nbr_read  %u, nbr_write %u\n",data->nbr_read,data->nbr_write);
  1085.     data->disk_car->clean(data->disk_car);
  1086.     FREE(data->disk_car);
  1087.     FREE(disk_car->data);
  1088.     disk_car->data=NULL;
  1089.   }
  1090.   return 0;
  1091. }
  1092.  
  1093. static t_param_disk *new_diskcache(t_param_disk *disk_car)
  1094. {
  1095.   struct info_cache*data=MALLOC(sizeof(*data));
  1096.   t_param_disk *new_disk_car=MALLOC(sizeof(*new_disk_car));
  1097.   memcpy(new_disk_car,disk_car,sizeof(*new_disk_car));
  1098.   data->disk_car=disk_car;
  1099.   data->nbr_read=0;
  1100.   data->nbr_write=0;
  1101.   new_disk_car->halt_on_errors=0;
  1102.   new_disk_car->write_used=0;
  1103.   new_disk_car->data=data;
  1104.   new_disk_car->description=disk_car->description;
  1105.   new_disk_car->read=cache_read;
  1106.   new_disk_car->write=cache_write;
  1107.   new_disk_car->clean=cache_clean;
  1108.   return new_disk_car;
  1109. }
  1110. #endif
  1111.